import random  # used for generating large random lists
import string  # used for string sorting tests
import sys  # used for min/max int tests

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# --- BASIC TEST CASES ---

def test_sorter_empty_list():
    # Test sorting an empty list
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 8.88μs -> 7.88μs (12.7% faster)

def test_sorter_single_element():
    # Test sorting a single-element list
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.58μs -> 7.88μs (21.7% faster)

def test_sorter_already_sorted():
    # Test sorting an already sorted list
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.96μs -> 7.96μs (25.1% faster)

def test_sorter_reverse_sorted():
    # Test sorting a reverse-sorted list
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.4μs -> 7.96μs (30.9% faster)

def test_sorter_unsorted_integers():
    # Test sorting a typical unsorted list of integers
    arr = [3, 1, 4, 1, 5, 9, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.9μs -> 8.04μs (35.8% faster)

def test_sorter_with_duplicates():
    # Test sorting a list with duplicate values
    arr = [2, 3, 2, 1, 3, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.5μs -> 7.92μs (32.6% faster)

def test_sorter_negative_numbers():
    # Test sorting a list with negative numbers
    arr = [-3, -1, -2, 0, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.58μs -> 8.25μs (16.2% faster)

def test_sorter_mixed_sign_numbers():
    # Test sorting a list with both positive and negative numbers
    arr = [-10, 0, 5, -3, 8, -2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.2μs -> 7.92μs (28.4% faster)

def test_sorter_floats():
    # Test sorting a list of floats
    arr = [3.1, 2.2, 5.5, 1.0, 4.4]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 12.2μs -> 9.00μs (35.2% faster)

def test_sorter_mixed_ints_and_floats():
    # Test sorting a list with both ints and floats
    arr = [1, 2.2, 3, 0.5, -1, -2.5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 11.6μs -> 9.29μs (24.7% faster)

def test_sorter_strings():
    # Test sorting a list of strings alphabetically
    arr = ["banana", "apple", "cherry", "date"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.3μs -> 8.38μs (22.9% faster)

def test_sorter_strings_case_sensitive():
    # Test sorting a list of strings with mixed case
    arr = ["Banana", "apple", "Cherry", "date"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.71μs -> 8.25μs (17.7% faster)

# --- EDGE TEST CASES ---

def test_sorter_all_identical():
    # Test sorting a list where all elements are identical
    arr = [7] * 10
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.7μs -> 8.00μs (33.9% faster)

def test_sorter_two_elements_sorted():
    # Test sorting a two-element list that is already sorted
    arr = [1, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 8.58μs -> 7.79μs (10.2% faster)

def test_sorter_two_elements_unsorted():
    # Test sorting a two-element list that is unsorted
    arr = [2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.38μs -> 7.79μs (20.3% faster)

def test_sorter_large_negative_and_positive():
    # Test sorting with very large and very small integers
    arr = [sys.maxsize, -sys.maxsize - 1, 0, 1, -1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 11.2μs -> 8.42μs (33.7% faster)

def test_sorter_with_none_raises():
    # Test that sorting a list containing None raises a TypeError
    arr = [1, None, 2]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 45.6μs -> 41.7μs (9.39% faster)

def test_sorter_mixed_types_raises():
    # Test that sorting a list with incompatible types raises a TypeError
    arr = [1, "two", 3]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 43.2μs -> 41.2μs (4.75% faster)

def test_sorter_immutable_input():
    # Test that the input list is mutated in place (since the function sorts in place)
    arr = [3, 2, 1]
    sorter(arr) # 9.58μs -> 7.92μs (21.0% faster)

def test_sorter_empty_string_list():
    # Test sorting a list of empty strings
    arr = ["", "", ""]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.2μs -> 8.17μs (25.0% faster)

def test_sorter_unicode_strings():
    # Test sorting a list of unicode strings
    arr = ["α", "β", "γ", "δ", "ε"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 11.7μs -> 9.08μs (28.9% faster)

def test_sorter_special_characters():
    # Test sorting a list with special characters
    arr = ["!", "@", "#", "$", "%"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.9μs -> 8.17μs (33.7% faster)

# --- LARGE SCALE TEST CASES ---

def test_sorter_large_sorted_list():
    # Test sorting a large already sorted list (best case)
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 19.8ms -> 35.2μs (56152% faster)

def test_sorter_large_reverse_list():
    # Test sorting a large reverse-sorted list (worst case for bubble sort)
    arr = list(range(999, -1, -1))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 32.9ms -> 35.5μs (92558% faster)

def test_sorter_large_random_list():
    # Test sorting a large random list
    arr = random.sample(range(-10000, -9000), 1000)
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 30.1ms -> 70.1μs (42854% faster)

def test_sorter_large_duplicates():
    # Test sorting a large list with many duplicates
    arr = [random.choice([0, 1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 27.3ms -> 60.4μs (45152% faster)

def test_sorter_large_strings():
    # Test sorting a large list of random strings
    arr = [
        ''.join(random.choices(string.ascii_letters + string.digits, k=5))
        for _ in range(1000)
    ]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 31.7ms -> 100μs (31397% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for generating large test cases
import string  # used for string sorting test cases
import sys  # used for edge cases with extreme values

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# -------------------- BASIC TEST CASES --------------------

def test_sorter_basic_sorted():
    # Already sorted list
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.8μs -> 8.12μs (32.3% faster)

def test_sorter_basic_reverse():
    # Reverse sorted list
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.9μs -> 7.96μs (37.2% faster)

def test_sorter_basic_unsorted():
    # Random unsorted list
    arr = [3, 1, 4, 5, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.6μs -> 7.71μs (37.3% faster)

def test_sorter_basic_duplicates():
    # List with duplicates
    arr = [2, 3, 2, 1, 3]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.6μs -> 7.88μs (34.4% faster)

def test_sorter_basic_single_element():
    # Single element list
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.58μs -> 8.04μs (19.2% faster)

def test_sorter_basic_two_elements_sorted():
    # Two elements, already sorted
    arr = [1, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 9.67μs -> 7.83μs (23.4% faster)

def test_sorter_basic_two_elements_unsorted():
    # Two elements, unsorted
    arr = [2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.0μs -> 7.88μs (27.5% faster)

def test_sorter_basic_negative_numbers():
    # List with negative numbers
    arr = [-3, -1, -2, 0, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.7μs -> 8.12μs (31.3% faster)

def test_sorter_basic_all_equal():
    # All elements are the same
    arr = [7, 7, 7, 7]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.2μs -> 7.88μs (30.2% faster)

# -------------------- EDGE TEST CASES --------------------

def test_sorter_edge_empty():
    # Empty list
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 7.92μs -> 7.71μs (2.71% faster)

def test_sorter_edge_large_negative_and_positive():
    # Large negative and positive numbers
    arr = [sys.maxsize, -sys.maxsize-1, 0, 999, -999]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 11.9μs -> 8.58μs (38.3% faster)

def test_sorter_edge_floats():
    # List with floats and integers
    arr = [3.2, 1, 2.5, 0, -1.1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 13.8μs -> 9.25μs (49.5% faster)

def test_sorter_edge_strings():
    # List of strings
    arr = ["banana", "apple", "cherry"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.4μs -> 8.33μs (25.0% faster)

def test_sorter_edge_mixed_types_raises():
    # List with mixed types should raise TypeError
    arr = [1, "a", 2]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 44.3μs -> 41.5μs (6.83% faster)

def test_sorter_edge_already_sorted_with_duplicates():
    # Already sorted with duplicates
    arr = [1, 1, 2, 2, 3, 3]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 10.6μs -> 7.96μs (33.0% faster)

def test_sorter_edge_large_identical_elements():
    # Large list of identical elements
    arr = [0] * 100
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 155μs -> 10.6μs (1361% faster)

def test_sorter_edge_single_large_value():
    # List with one very large value among small values
    arr = [1, 2, 3, 10**18, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 11.5μs -> 8.42μs (36.1% faster)

def test_sorter_edge_single_small_value():
    # List with one very small value among large values
    arr = [10**18, 2, 3, 4, 5, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 12.1μs -> 8.58μs (40.8% faster)

def test_sorter_edge_non_ascii_strings():
    # List of non-ASCII strings
    arr = ["éclair", "apple", "zebra", "Álgebra"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 11.6μs -> 8.92μs (29.9% faster)

# -------------------- LARGE SCALE TEST CASES --------------------

def test_sorter_large_sorted():
    # Large already sorted list
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 19.6ms -> 35.7μs (54907% faster)

def test_sorter_large_reverse():
    # Large reverse sorted list
    arr = list(range(999, -1, -1))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 33.0ms -> 35.4μs (93181% faster)

def test_sorter_large_random():
    # Large random list
    arr = list(range(1000))
    random.shuffle(arr)
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 28.9ms -> 66.7μs (43244% faster)

def test_sorter_large_duplicates():
    # Large list with many duplicates
    arr = [random.choice([1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 26.9ms -> 59.0μs (45515% faster)

def test_sorter_large_strings():
    # Large list of random strings
    arr = [''.join(random.choices(string.ascii_letters, k=5)) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 32.2ms -> 101μs (31704% faster)

def test_sorter_large_all_same():
    # Large list of all the same value
    arr = [42] * 1000
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 19.6ms -> 33.8μs (57950% faster)

def test_sorter_large_alternating():
    # Large list alternating two values
    arr = [0, 1] * 500
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 23.6ms -> 49.7μs (47308% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.